home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr53 / pctv4n_1.zip / QEDICT.C < prev    next >
C/C++ Source or Header  |  1993-06-10  |  8KB  |  384 lines
  1. /**************************************************
  2. * FILE NAME:  QEdict.c     TITLE: dictionary listing
  3. *
  4. * AUTHOR:  K. E. North II, Resource Group, Inc.
  5. *
  6. * SYNOPSIS:
  7. * 
  8. *    List record structure info for Q+E Lib
  9. *            
  10. ***************************************************
  11. *
  12. *    initialize (strings, counts, error_status)
  13. *    assign variables to table, view
  14. *
  15. *    initiate data base connection -
  16. *         dbConnect() to login, get cursor 
  17. *    execute SQL
  18. *         dbRequest() - prep/exec SQL statement
  19. *
  20. *    IF status <> 0 then
  21. *        while <> end of data:
  22. *             get dictionary info (dbDescribe)
  23. *            format and list columns
  24. *    ELSE
  25. *        process system error message 
  26. *        ENDIF
  27. *    terminate data base connection: dbClose()
  28. *
  29. ***************************************************/
  30.  
  31. #include <stdio.h>
  32. #include <stdlib.h>
  33. #include <conio.h>
  34. #include <string.h>
  35. #include <windows.h>
  36.  
  37. #ifndef __QEDEFS_H
  38. #include "QEdefs.h"
  39. #endif
  40.  
  41. #ifndef __QEVARBL_H
  42. #include "QEvarbl.h"
  43. #endif
  44.  
  45.  
  46. #ifndef __QEFUNCS_H
  47. #include "qefuncs.h"
  48. #endif
  49.  
  50. #ifndef __DBTYPES_H
  51. #include "dbtypes.h"
  52. #endif
  53.  
  54. #ifndef __REQUEST_H
  55. #include "request.h"
  56. #endif
  57.  
  58. #ifndef __RQOPTION_H
  59. #include "rqoption.h"
  60. #endif
  61.  
  62. #ifndef __QCOLINFO_H
  63. #include "qcolinfo.h"
  64. #endif
  65.  
  66. #ifndef __DATASRC_H
  67. #include "datasrc.h"
  68. #endif
  69.  
  70. #include "qedict.h"
  71.  
  72. #undef DEBUG
  73. #undef DEBUG1
  74.  
  75. #define RCOUNT        10
  76. #define DISPLAYLEN    20
  77.  
  78.  
  79. int        ExitStatus;
  80. int        StatusReturned;
  81.  
  82. static char    DBDictPath[80];
  83. static char    DBTable[32];
  84. static char    DBDriver[9];
  85.  
  86. char    *table;
  87. char    *dictpath;
  88. char    *driver;
  89.  
  90. COLUMNS ColInfo[MAXFIELD];
  91. COLUMNS *fi;
  92.  
  93. struct ConnectionInfo *si;
  94. struct ViewInfo *vu;
  95. struct DataSource *dsrc;
  96. struct SQLRequest *rq;
  97. struct RequestOptions *op;
  98.  
  99.  
  100.  
  101. void main (int argc, char *argv[])
  102. {
  103.  
  104. HSTMT    hstmt;
  105. POINTER    statement;
  106.  
  107.  
  108. int nColumns;
  109. int    ColPosition;
  110. int    ColCount;
  111. int    flen;        /* string length of field name */
  112. int i;                /* blank fill loop index   */
  113. int TotalLength;     /* sum of field lengths */
  114.  
  115. static char    SQLString[MAXSQL];
  116. static char    DictColName[DISPLAYLEN+1];
  117. char        *ColDataType;
  118.  
  119.                     /* allocate memory */
  120.     op = calloc(1, sizeof(struct RequestOptions));       
  121.     si = calloc(1, sizeof(struct ConnectionInfo));       
  122.     rq = calloc(1, sizeof(struct SQLRequest));
  123.     vu = calloc(1, sizeof(struct ViewInfo));
  124.     dsrc = calloc(1, sizeof(struct DataSource));
  125.  
  126.                         /* initialize strings */
  127.     memset(SQLString,'\x0',sizeof(SQLString));
  128.     memset(DBDictPath,'\x0',sizeof(DBDictPath));
  129.     memset(DBTable,'\x0',sizeof(DBTable));
  130.     memset(DBDriver,'\x0',sizeof(DBDriver));
  131.  
  132.     table         = &DBTable[0];
  133.     dictpath     = &DBDictPath[0];
  134.     driver        = &DBDriver[0];
  135.     StatusReturned = SQL_SUCCESS;
  136.     GetArgs(argc,argv[1],argv[2],argv[3],
  137.         table,dictpath,driver);
  138.  
  139.             /* make selection of database type */
  140.     strcpy (dsrc->DBDriver, driver);
  141. /*    if (strcmp,QEPDX)
  142.         {
  143.         strcpy (dsrc->DBDriver, "QEPDX");
  144.         }
  145.     if (strcmp,QEDBF)
  146. */    
  147.  
  148.             /* for DBF and PDX, same dict and datapath */
  149.     strcpy (dsrc->DBDictPath, dictpath);
  150.     strcpy (dsrc->DBDataPath, dictpath);
  151.     op->UseDirectExec    = TRUE;
  152.     op->RequiresCursor     = FALSE;
  153.     op->UseTransaction     = FALSE;
  154.     rq->CursorID = 0;    /* no cursor used for QEDBF */
  155.  
  156.     /*******************************************/
  157.     /* open data base - connect to data source */
  158.     /*******************************************/
  159.  
  160.     strcpy (si->DataPath, dsrc->DBDictPath);
  161.     strcpy (si->DictPath, dsrc->DBDictPath);
  162.  
  163.             /* may require revision for named cursors */
  164.     StatusReturned = dbConnect (si, dsrc);
  165.     if ((StatusReturned != SQL_SUCCESS))
  166.         {
  167.         printf
  168.         ("\n<QEDict> ERROR %d: Unable to connect to %s",
  169.                 si->hdbc, dsrc->DBDriver);
  170.  
  171.         exit (1);
  172.         }
  173.  
  174.                         /* specify query string */
  175.     strcpy(SQLString,"SELECT * FROM ");
  176.  
  177.     strcat(SQLString,dsrc->DBDataPath);
  178.     SQLString[strlen(SQLString)] = '\x5c';
  179.     strcat(SQLString,DBTable);
  180.  
  181.                     /************************/
  182.                     /*  prepare and execute */
  183.                     /************************/
  184.     StatusReturned = SQL_SUCCESS;
  185.  
  186.             /* may require revision for named cursors */
  187.     StatusReturned = dbRequest( rq, SQLString, si);
  188.     if ((StatusReturned != SQL_SUCCESS))
  189.         {
  190.         if (StatusReturned < 0 )
  191.             {
  192.             printf 
  193.             ("\n<QEdict> STATUS: preparing  %s\n",
  194.                      SQLString);
  195.             }
  196.         else
  197.             {
  198.             printf 
  199.             ("\n<QEdict> ERROR: preparing  %s\n", 
  200.                     SQLString);
  201.             exit (1);
  202.             }
  203.         }
  204.  
  205.         /* Loop to get the description for each    */
  206.         /* column of the table. Set the loop count */
  207.         /* from the number of columns for this     */
  208.         /* request's SQL statement                    */
  209.     nColumns = FindNumberOfColumns(rq->hstmt);
  210.  
  211.                         /************************/
  212.                         /*  get dictionary         */
  213.                         /************************/
  214.  
  215.     printf ("\nStructure for table: %s\n", DBTable);                
  216.     printf ("Column   Column Name              Type\
  217.       Width  Dec\n");
  218.  
  219.     StatusReturned = SQL_SUCCESS;            
  220.  
  221.     ColPosition = 0; 
  222.     vu->ColCount = 0;
  223.     TotalLength = 0;
  224.  
  225.     do
  226.         {
  227.                     /* point to column descriptor */
  228.         fi = &ColInfo[ColPosition];
  229.         StatusReturned = SQL_SUCCESS;
  230.  
  231.                 /* get data dictionary for 
  232.                 the current cursor ID */
  233.         StatusReturned = 
  234.             dbDescribe( ColPosition+1,
  235.                             fi,  rq );
  236.  
  237.         if ((StatusReturned != SQL_SUCCESS))
  238.             {
  239.             if (StatusReturned == ENDFILE)
  240.               {
  241.                 #ifdef DEBUG
  242.                 printf ("\n<QEDict> end of data dictionary\n");
  243.                 #endif
  244.               break;
  245.               }
  246.             else
  247.               {
  248.             printf 
  249.               ("\n<QEdict> ERROR %d: \n",
  250.                 StatusReturned);
  251.             printf 
  252.               ("\n getting data dictionary for %s\n", 
  253.                   SQLString);
  254.               exit (1);
  255.               }
  256.             };
  257.     vu->ColCount++;        /* update column count */
  258.  
  259.                         /* re-calc cols length */
  260.     TotalLength +=
  261.         ColInfo[ColPosition].Length;
  262.  
  263.     ColDataType = DecodeQEDataType(fi->DataType);
  264.     strcpy(DictColName,fi->ColName);
  265.     flen = strlen(fi->ColName);
  266.     for ( i=flen; i < DISPLAYLEN; i++ );
  267.         {
  268.         DictColName[i]='\x20';
  269.         }
  270.     DictColName[DISPLAYLEN]='\x0';
  271.     printf 
  272.     ("\n %3.0i  %20.20s  %12.12s   %5d  %2d",
  273.                         vu->ColCount,
  274.                         DictColName,
  275.                         ColDataType,
  276.                         fi->Length,
  277.                         fi->Scale);
  278.  
  279.     ColPosition++;
  280.         }
  281.     while (ColPosition < nColumns);
  282.  
  283.                     /* display summary */
  284.     printf ("\nTotal length: %d\n",TotalLength);
  285.  
  286.                         /****************/
  287.                         /*    close        */
  288.                         /****************/
  289.     StatusReturned = dbClose (si);
  290.     if ( StatusReturned )
  291.         {
  292.         printf 
  293.           ("\n<QEdict> ERROR %d: \n",
  294.             StatusReturned);
  295.         printf 
  296.           ("\n dbClose failed, disconnecting \
  297.           from: %s\n", dsrc->DBDriver);
  298.         exit (1);
  299.         }
  300. }
  301.  
  302. /**************************************************
  303. * FUNCTION NAME: GetArgs
  304. *
  305. * AUTHOR:         Ken North 
  306. *
  307. * SYNOPSIS:
  308. *
  309. *     get table name and dictionary path from 
  310. *    command line or user
  311. *
  312. ***************************************************/
  313.  
  314. void GetArgs(int argc, char *arg1, char *arg2, 
  315.         char *arg3, char *table, char *dict, 
  316.         char *driver)
  317. {
  318. static char name [80]; 
  319.  
  320.   if (argc > 1)
  321.     {
  322.     memset(name,'\x0',sizeof(name));
  323.     if (*arg1 == '?')
  324.       {
  325.       printf("\n  Usage: QEDICT table \
  326.  dictionarypath\n");
  327.       printf ("\n QEDICT    QE Lib\
  328. data definitions\n");
  329.       printf("   (Requires QELIB DLL\
  330. or QExxx.DLL)\n\n");
  331.       printf
  332.       ("    To display a data dictionary screen, \
  333.       type:\n");
  334.       printf
  335.       ("       QEDICT table dictpath driver| \
  336. MORE\n\n");
  337.       printf
  338.       ("    To list to a file, type:\n");
  339.       printf
  340.       ("       QEDICT table dictpath driver> \
  341. listfile\n\n\n");
  342.       exit(1);
  343.       }            
  344.     strcpy (name, arg1);
  345.     strupr (name);  /* translate to upper case */
  346.     strcpy(table,name) ;     /* copy name to table */
  347.     memset(name,'\x0',sizeof(name));
  348.     }
  349.   if (argc > 2)
  350.     {
  351.     strcpy (name, arg2);
  352.     strupr (name);    /* translate to upper case */
  353.     strcpy(dict,name) ;
  354.     memset(name,'\x0',sizeof(name));
  355.     }
  356.   if (argc > 3)
  357.     {
  358.     strcpy (name, arg3);
  359.     strupr (name); /* translate to upper case */
  360.     strcpy(driver,name) ;
  361.     }
  362.   if (argc < 2)
  363.       {
  364.       printf ("Table name ? ");
  365.       gets (name);
  366.       puts ("\n");
  367.       strupr (name);    /* translate to upper case */
  368.       strcpy(table,name) ;
  369.       memset(name,'\x0',sizeof(name)); /* zero name */
  370.       printf ("Dictionary pathname ? ");
  371.       gets (name);
  372.       puts ("\n");
  373.       strupr (name); 
  374.       strcpy(dict,name) ;
  375.       memset(name,'\x0',sizeof(name)); /* zero name */
  376.       printf ("Database driver ? ");
  377.       gets (name);
  378.       puts ("\n");
  379.       strupr (name); 
  380.       strcpy(driver,name) ;
  381.       }
  382. }
  383.  
  384.